home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML Authority.sea / XML Authority / Required / tamino / TaminoLib.js < prev   
Encoding:
Text File  |  2000-05-03  |  20.6 KB  |  743 lines  |  [BINA/hDmp]
  1. //For use with ASP replace this line with
  2. //Tamino Java Script Object for IE5.0
  3. //Software AG -Technical Services
  4. //Nigel W. O. Hutchison 
  5.  
  6. var inoVersion="1.2.1.2";
  7.  
  8. var inoUserAgent="Tamino Client/Java Script/IE5.0 ";
  9. var inoVersion="1.2.1.1";
  10. var inoErrorText= new Array();
  11. var inoEnoErrorBase=8400;
  12. var inoComponent="INOXJE";
  13. var inoTransportErrorNo=inoEnoErrorBase+0;
  14.     inoErrorText[0]="HTTP Error ";
  15. var inoParserErrorNo=inoEnoErrorBase+1;
  16.     inoErrorText[1]="Parser Error ";
  17. var inoSessionOpenErrorNo=inoEnoErrorBase+2;
  18.     inoErrorText[2]="Session already open";
  19. var inoSessionNotOpenErrorNo=inoEnoErrorBase+3;
  20.      inoErrorText[3]="No session open";
  21. var inoSessionFailureErrorNo=inoEnoErrorBase+4;
  22.     inoErrorText[4]="No session established";
  23. var inoURLdidNotExistNo=inoEnoErrorBase+5;
  24.     inoErrorText[5]="URL did not exist";
  25. var inoDeleteNotSpecifiedNo=inoEnoErrorBase+6;
  26.     inoErrorText[6]="Document to be Deleted not Specified";
  27. var inoInvalidNodeTypeNo=inoEnoErrorBase+7;
  28.     inoErrorText[7]="Invalid Node Type";
  29. var inoSessionIdErrorNo=inoEnoErrorBase+8;
  30.     inoErrorText[8]="Invalid sessionID received from Server";
  31. var inoNoXMLErrorNo=inoEnoErrorBase+9;
  32.     inoErrorText[9]="No Tamino Response Returned";
  33.  
  34. //Microsoft XMLDOM node constants
  35. var NODE_ELEMENT=1;
  36. var NODE_ATTRIBUTE = 2; 
  37. var NODE_TEXT = 3; 
  38. var NODE_CDATA_SECTION = 4; 
  39. var NODE_ENTITY_REFERENCE =5; 
  40. var NODE_ENTITY = 6; 
  41. var NODE_PROCESSING_INSTRUCTION =7; 
  42. var NODE_COMMENT = 8; 
  43. var NODE_DOCUMENT = 9; 
  44. var NODE_DOCUMENT_TYPE = 10; 
  45. var NODE_DOCUMENT_FRAGMENT = 11; 
  46. var NODE_NOTATION = 12; 
  47.  
  48.  function TaminoClient()
  49. {
  50.     //define properties
  51.     this.XMLDB =""; 
  52.     this.securePath="";
  53.     this.lastQuery=""; //f2
  54.     this.pageSize=5;
  55.     this.user="";
  56.     this.password="";
  57.     this.transaction=null;
  58.     this.xmlHeader='<?xml version="1.0"?>'; //default - UTF-8;
  59.     this.userAgent=inoUserAgent+inoVersion;
  60.     this.acceptLanguage="en";
  61.     this.charset="utf-8";
  62.     this.acceptCharset="utf-8";
  63.     var argv=arguments;
  64.     var argc=arguments.length;
  65.     if    (argc > 0)
  66.         {
  67.         this.XMLDB=argv[0];
  68.         }
  69.     if    (argc > 1)
  70.         this.pageSize=arguments[1];
  71.     if    (argc > 2)
  72.         this.user=arguments[2];
  73.     if    (argc > 3)
  74.         this.password=arguments[3];    
  75.     
  76.     
  77.     
  78.     
  79. } 
  80. function TaminoTransaction()  //transaction class
  81.     {
  82.     this.tid = null;
  83.     this.key = null;
  84.     this.errorNo=0;
  85.     this.errorText="";
  86.     if    (arguments.length> 0) this.tid=arguments[0];
  87.     if    (arguments.length> 1) this.key=arguments[1];
  88.     }
  89.  
  90.  
  91. function TaminoResult(queryo,req,noBody) //result class
  92. {
  93.     //define properties
  94.     
  95.     
  96.     this.queryObj=queryo;
  97.     
  98.     this.REQ=req;
  99.     this.DOM=null;
  100.     this.lastQuery="";
  101.     this.pageSize=5;
  102.     this.user="";
  103.     this.password="";
  104.     this.errorNo=0;
  105.     this.errorText=""; 
  106.     this.securePath=queryo.securePath;
  107.         
  108.     if    (this.REQ)
  109.         {
  110.         var status = this.REQ.status;
  111.         if    (status >= "300")
  112.             {
  113.             this.errorNo=inoTransportErrorNo;
  114.             this.errorText=TaminoClientErrorText(inoTransportErrorNo,status,this.REQ.statusText);
  115.             }
  116.         else      { 
  117.             //this.DOM=new ActiveXObject("Microsoft.XMLDOM");
  118.             //should we check if there is a response entity?
  119.             if    (noBody)return;
  120.             
  121.             this.DOM=this.REQ.responseXML;
  122.             if    (!this.DOM.documentElement)
  123.                 {
  124.                 this.errorNo=inoNoXMLErrorNo;
  125.                 this.errorText=TaminoClientErrorText(inoNoXMLErrorNo);
  126.                 return;
  127.                 }
  128.             var p = this.DOM.parseError;
  129.             if    ( p.errorCode!="0")
  130.                 {
  131.                 this.errorNo=inoParserErrorNo;
  132.                 this.errorText=TaminoClientErrorText(inoParserErrorNo,
  133.                      p.errorCode,p.reason);
  134.                 }
  135.             else    {
  136.                 var message = this.ErrorNode();
  137.                 
  138.                 if (message)
  139.                     {
  140.                     this.errorNo=Number(message.getAttribute("ino:returnvalue"));
  141.                     var node = message.selectSingleNode("ino:messagetext");
  142.                     var text=this.errorNo;
  143.                     if (node) text= node.getAttribute("ino:code")+" "+node.text;                        text= node.getAttribute("ino:code")
  144.                             +" "+node.text;
  145.                     var lines=message.selectNodes("ino:messageline");
  146.                     if    (lines)
  147.                         {
  148.                         var l=lines.length;
  149.                         for (var j=0;j<l;j++)
  150.                             {
  151.                             var line =lines.item(j);
  152.                             text=text+', '+line.text;
  153.                             }
  154.                         }
  155.                     this.errorText=text;
  156.                     }
  157.                         
  158.                 var tran = this.queryObj.transaction;
  159.                 if    (tran)
  160.                     {
  161.                     if    (!tran.update(this.DOM))
  162.                         {
  163.                         this.errorNo=
  164.                             tran.errorNo;
  165.                         this.errorText=
  166.                             tran.errorText;
  167.                         }
  168.                     }
  169.                 }
  170.                 
  171.                     
  172.             }
  173.         }
  174. } 
  175.  
  176.  
  177. TaminoClient.prototype.query= function (xqlquery)
  178. {
  179.     var cursor;
  180.     var pageSize= parseInt(this.pageSize);
  181.     if    (pageSize>0)
  182.         cursor="?_XQL(1,"+pageSize+")="+this.escape(xqlquery);
  183.     else     cursor="?_XQL="+this.escape(xqlquery);
  184.     if     (arguments.length > 1)
  185.         return(this.queryCursor(cursor,arguments[1]));
  186.     else    return(this.queryCursor(cursor));
  187. }
  188. TaminoClient.prototype.queryCursor=function(cursorQuery)
  189. {
  190.     var extraPath = "";
  191.     if    (arguments.length > 1)
  192.         extraPath=arguments[1];
  193.     var session= this.tEncoded();
  194.     if    (session !="") session="&"+session;
  195.     this.lastQuery=this.XMLDB+extraPath+cursorQuery+session;
  196.     
  197.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  198.     REQ.open("GET",this.lastQuery,
  199.         false,this.user,this.password);
  200.     REQ.setRequestHeader("User-Agent",this.userAgent);
  201.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  202.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  203.     REQ.setRequestHeader("Cache-Control","no-cache");
  204.     //REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  205.     REQ.send("");
  206.     var result = new TaminoResult(this,REQ);
  207.     result.lastCursor=cursorQuery;
  208.     return(result);
  209. }
  210. TaminoClient.prototype.querydelete=function(query)
  211. {
  212.     if     (arguments.length > 1)
  213.         this.lastQuery=this.XMLDB+arguments[1];
  214.     else   this.lastQuery=this.XMLDB+this.securePath;
  215.     var clause =this.escape(query)
  216.     var session=this.tEncoded();
  217.     if    (session != "") session="&"+session;
  218.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  219.     REQ.open("POST",this.lastQuery,false,this.user,this.password);
  220.     REQ.setRequestHeader("User-Agent",this.userAgent);
  221.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  222.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  223.     //REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  224.     REQ.send("_DELETE="+clause+session);
  225.     var result = new TaminoResult(this,REQ);
  226.     return(result);
  227. }
  228. TaminoClient.prototype.inodelete=function(node)
  229. {
  230.     if    (node && (node.nodeType == NODE_ELEMENT
  231.             || node.nodeType == NODE_DOCUMENT))
  232.         {
  233.         
  234.         var clause = node.nodeName+'[@ino:id="'
  235.             +node.getAttribute("ino:id")+'"]';
  236.         if     (arguments.length > 1)
  237.             return(this.querydelete(clause,arguments[1]));
  238.         else     return(this.querydelete(clause));
  239.         }
  240.     else    {
  241.         var result = new TaminoResult(this,null);
  242.         result.erroNo=inoDeleteNotSpecifiedNo;
  243.         result.errorText=TaminoClientErrorText(inoDeleteNotSpecifiedNo);
  244.         }
  245.     return(result);
  246. }
  247. TaminoClient.prototype.escape=function(myString)
  248. {
  249. var out="";
  250. var length=myString.length;
  251. for (var i=0;i<length;i++)
  252.     {
  253.     var char = myString.charAt(i);
  254.     var val=char.charCodeAt(0);
  255.     if    (val > 255)
  256.         {
  257.         out = out + "&#"+val+";";
  258.         }
  259.     else     {
  260.         out=out+char;
  261.         }
  262.     }
  263. return(escape(out));
  264. }
  265. TaminoClient.prototype.absoluteURL=function(reurl)
  266.     {
  267.     //check if URL is absolute
  268.     var urlPattern=/^http:/;
  269.     if    (reurl.match(urlPattern)!= null)
  270.         return(reurl);
  271.     else    return(this.XMLDB+"/"+reurl);
  272.     }
  273. TaminoClient.prototype.deleteDocument= function (reurl)
  274. {
  275.     this.lastQuery=this.absoluteURL(reurl);
  276.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  277.     REQ.open("DELETE",this.lastQuery,false,this.user,this.password);
  278.     REQ.setRequestHeader("User-Agent",this.userAgent);
  279.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  280.         REQ.send("");
  281.     var result=new TaminoResult(this,REQ,true);
  282.     return(result);
  283. }
  284. TaminoClient.prototype.getDocument=function (reurl)
  285. {
  286.     this.lastQuery=this.absoluteURL(reurl);
  287.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  288.     REQ.open("GET",this.lastQuery,false,this.user,this.password);
  289.     REQ.setRequestHeader("User-Agent",this.userAgent);
  290.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  291.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  292.     REQ.setRequestHeader("Cache-Control","no-cache");
  293.     REQ.send("");
  294.     var result=new TaminoResult(this,REQ);
  295.     return(result);
  296. }    
  297. TaminoClient.prototype.putDocument=function (reurl,node)
  298. {
  299.     var header;
  300.     this.lastQuery=this.absoluteURL(reurl);
  301.     if    (node.nodeType == NODE_ELEMENT)
  302.         header = this.xmlHeader;
  303.     else     {if (node.nodeType == NODE_DOCUMENT)
  304.             header="";
  305.         else {
  306.             var r = new TaminoResult(this,null);
  307.             r.errorNo=inoInvalidNodeTypeNo;
  308.             r.errorText=TaminoClientErrorText(inoInvalidNodeTypeNo,node.nodeType);
  309.             return(r);
  310.              }
  311.         }
  312.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  313.     REQ.open("PUT",this.lastQuery,false,this.user,this.password);
  314.     REQ.setRequestHeader("User-Agent",this.userAgent);
  315.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  316.     REQ.setRequestHeader("Content-Type","text/xml; charset="+this.charset);
  317.     REQ.send(header+node.xml);
  318.     var result=new TaminoResult(this,REQ,true);
  319.     return(result);
  320. }
  321. TaminoClient.prototype.head=function (reurl)
  322. {
  323.     this.lastQuery=this.absoluteURL(reurl);
  324.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  325.     REQ.open("HEAD",this.lastQuery,false,this.user,this.password);
  326.     REQ.setRequestHeader("User-Agent",this.userAgent);
  327.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  328.     REQ.send("");
  329.     var result=new TaminoResult(this,REQ,true);
  330.     return(result);
  331. }
  332.         
  333. TaminoClient.prototype.process=function(node)
  334.     {
  335.     var header;
  336.     var nodeType=node.nodeType;
  337.     if    (nodeType == NODE_ELEMENT)
  338.         header = this.xmlHeader;
  339.     else     {if (nodeType == NODE_DOCUMENT)
  340.             header="";
  341.         else {
  342.             var r = new TaminoResult(this,null);
  343.             r.errorNo=inoInvalidNodeTypeNo;
  344.             r.errorText=TaminoClientErrorText(inoInvalidNodeTypeNo,nodeType);
  345.             return(r);
  346.              }
  347.         }
  348.     
  349.     if     (arguments.length > 1)
  350.         this.lastQuery=this.XMLDB+arguments[1];
  351.     else   this.lastQuery=this.XMLDB+this.securePath;
  352.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  353.     REQ.open("POST",this.lastQuery,false,this.user,this.password);
  354.     var session=this.tEncoded();
  355.     if    (session) session=session+"&";
  356.     REQ.setRequestHeader("User-Agent",this.userAgent);
  357.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  358.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  359.     REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  360.     REQ.send(session+"_PROCESS="+this.escape(header+node.xml));
  361.     var r = new TaminoResult(this,REQ);
  362.     return(r);
  363. }
  364.  
  365. TaminoResult.prototype.cursor=function(attr)
  366.     {
  367.     var query = this.getCursorQuery(attr);
  368.     
  369.     if    (query)    return(this.queryObj.queryCursor(query));
  370.     return(this); 
  371. }
  372. TaminoResult.prototype.rObject= function()
  373. {
  374.     var rObjNodelist =this.DOM.getElementsByTagName("ino:object");
  375.     if      (rObjNodelist)return(rObjNodelist.item(0));
  376.     return(null);
  377. }
  378. TaminoResult.prototype.getInoId=function ()
  379. {
  380.     var rObj = this.rObject();
  381.     if    (rObj) return(rObj.getAttribute("ino:id"));
  382.     return(null);
  383. }
  384. TaminoResult.prototype.getDocType=function ()
  385. {
  386.     var rObj = this.rObject();
  387.     if    (rObj)    return(rObj.getAttribute("ino:doctype"));
  388.     return(null);
  389. }
  390. TaminoResult.prototype.getCollection=function ()
  391. {
  392.     var rObj = this.rObject();
  393.     if    (rObj)    return(rObj.getAttribute("ino:collection"));
  394.     return(null);
  395. }
  396. TaminoResult.prototype.getLocation=function()
  397. {
  398.     var location = this.REQ.getResponseHeader("Location");
  399.     if    (location) return (location);
  400.     var collection = this.getCollection();
  401.     var docType = this.getDocType();
  402.     var inoId= this.getInoId();
  403.     if    (collection && docType && inoId)        
  404.         return(this.queryObj.XMLDB+"/"+collection+"/"+docType+"/@"+inoId);
  405.     return(null);
  406.     }
  407.  
  408. TaminoResult.prototype.ErrorNode=function()
  409. {
  410.     var messages=this.DOM.getElementsByTagName("ino:message");
  411.     var messagesLength=messages.length;
  412.     var message;
  413.     var i;
  414.     var returnCode;
  415.     for     (i=0;i<messagesLength;i++)
  416.         {
  417.         message=messages.item(i);
  418.         returnCode = message.getAttribute("ino:returnvalue");
  419.         if    (returnCode!="0") return(message);
  420.         }
  421.     return(null);
  422. }
  423.  
  424.     
  425.  
  426. TaminoResult.prototype.nodes=function ()
  427.     {
  428.     var result = this.DOM.getElementsByTagName("xql:result").item(0);
  429.     if    (result) return(result.childNodes);
  430.     return(null);
  431.     }
  432. TaminoResult.prototype.getResult=function ()
  433.     {
  434.     var result = this.DOM.getElementsByTagName("xql:result").item(0);
  435.     return(result);
  436.     }
  437. TaminoResult.prototype.getFirst=function (){
  438.     return(this.cursor("first"));
  439.     }
  440. TaminoResult.prototype.getPrev=function (){
  441.     return(this.cursor("prev"));
  442.     }
  443. TaminoResult.prototype.getNext=function (){
  444.     
  445.     return(this.cursor("next"));
  446.     }
  447. TaminoResult.prototype.getLast=function (){
  448.     return(this.cursor("last"));
  449. }
  450. TaminoResult.prototype.refresh=function(){
  451.     if    (!this.lastCursor) return(this);
  452.     return(this.queryObj.queryCursor(this.lastCursor));
  453. }
  454.  
  455. TaminoResult.prototype.getCursorQuery=function (attr)
  456. {
  457.     var link = this.DOM.getElementsByTagName("ino:"+attr).item(0);
  458.     if    (link) return(link.getAttribute("ino:href"));
  459.     return("");
  460. }
  461. TaminoResult.prototype.getTotalCount=function()
  462. {
  463.     var doc;
  464.     var cursorList;
  465.     var nodes;
  466.     if    (doc=this.DOM)
  467.         {
  468.         if    (cursorList=doc.getElementsByTagName("ino:cursor"))
  469.             return(cursorList.item(0).getAttribute("ino:count"));
  470.         if    (nodes=this.nodes())
  471.             return(nodes.length);
  472.         }
  473.     return(null);
  474. }
  475. TaminoClient.prototype.insert=function (node)
  476. {
  477.     //clear ino:id
  478.     node.attributes.removeNamedItem("ino:id");
  479.     if    (arguments.length > 1)
  480.         return(this.process(node,arguments[1]));
  481.     return(this.process(node));
  482. }
  483. TaminoClient.prototype.update =function (node,inoid)
  484. {
  485.     //override inoId if it exists
  486.     inoidNode=node.ownerDocument.createAttribute("ino:id");
  487.     node.attributes.setNamedItem(inoidNode);
  488.     inoidNode.nodeValue=inoid;
  489.     if    (arguments.length > 2)
  490.         return(this.process(node,arguments[2]));
  491.     return(this.process(node));
  492. }
  493. TaminoClient.prototype.inoDoCommand=function(command,tidParam)
  494.     {
  495.     this.lastQuery=this.XMLDB+this.securePath;
  496.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  497.     REQ.open("POST",this.lastQuery,false,this.user,this.password);
  498.     //REQ.open("GET","http://pctamino2/tamino/newDB?_connect=*",false,this.user,this.password);
  499.     REQ.setRequestHeader("User-Agent",this.userAgent);
  500.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  501.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  502.     REQ.send(command+"=*&"+tidParam);    
  503.     result=new TaminoResult(this,REQ);
  504.     return(result);
  505.     }
  506. function TaminoClientErrorText(code)
  507.     {
  508.     var parameters="";
  509.     var l= arguments.length;
  510.     for(var i=1;i<l;i++){ parameters=parameters+" " + arguments[i];    }    
  511.     return (inoComponent+code+" "+inoErrorText[code-inoEnoErrorBase]+parameters);
  512.     //this should get the error text from the server if the langauge is not right
  513.     
  514.     }
  515. TaminoClient.prototype.SessionError=function(code)
  516.     {
  517.     var result= new TaminoResult(this,null);
  518.     result.errorNo=code;
  519.     result.errorText=TaminoClientErrorText(code);
  520.     return(result);            
  521.     }
  522.  
  523. TaminoClient.prototype.startSession= function ()
  524.     {
  525.     //test
  526.     if    (this.transaction!=null)
  527.         {
  528.         return(this.SessionError(inoSessionOpenErrorNo));
  529.         }
  530.     var result = this.inoDoCommand("_connect","");
  531.     
  532.     if    (!result.errorNo)
  533.         {
  534.         var root=result.DOM.getElementsByTagName("ino:response").item(0);
  535.         if    (root)
  536.             {
  537.             var tid = root.getAttribute("ino:sessionid");
  538.             var key = root.getAttribute("ino:sessionkey");
  539.             if    (tid && key)
  540.                 {
  541.                 this.errorNo=0;
  542.                 this.transaction=new TaminoTransaction(tid,key);
  543.                 return(result);
  544.                 }
  545.             }
  546.         result.errorNo=inoSessionFailureErrorNo;
  547.         result.errorText=TamTaminoClientErrorText(inoSessionFailureErrorNo);
  548.                 
  549.         }
  550.     return(result);
  551. }
  552. TaminoClient.prototype.endSession=function ()
  553.     {
  554.     var result;
  555.     if    (!this.transaction)
  556.         {
  557.         return(this.SessionError(inoSessionNotOpenErrorNo));
  558.           }
  559.     result = this.inoDoCommand("_disconnect",this.tEncoded());
  560.     this.transaction=null;
  561.     return(result);
  562. }
  563. TaminoClient.prototype.commit= function ()
  564.     {
  565.     var result;
  566.     if    (!this.transaction)
  567.         {
  568.         return(this.SessionError(inoSessionNotOpenErrorNo));
  569.           }
  570.     result=this.inoDoCommand("_commit",this.tEncoded());
  571.     return(result);
  572. }
  573. TaminoClient.prototype.rollback=function ()
  574.     {
  575.     var result;
  576.     if    (!this.transaction)
  577.         {
  578.         return(this.SessionError(inoSessionNotOpenErrorNo));
  579.           }
  580.     result = this.inoDoCommand("_rollback",this.tEncoded());
  581.     return(result);
  582.     }
  583.  
  584.  
  585. TaminoClient.prototype.tEncoded=function () 
  586.     {
  587.     if    (this.transaction)
  588.         return(this.transaction.encoded());
  589.     else    return("");
  590. }        
  591. TaminoClient.prototype.setEncoding=function(encoding)
  592.     {
  593.     if    (encoding == "")
  594.         {
  595.         this.xmlHeader='<?xml version="1.0"?>';
  596.         }
  597.     else    {
  598.         this.xmlHeader='<?xml version="1.0" encoding="'+encoding+'"?>';
  599.         }
  600.     }
  601. TaminoClient.prototype.setUserPassword=function(user,password)
  602.     {
  603.     this.user=user;
  604.     this.password=password;
  605.     }
  606.  
  607.  
  608. TaminoTransaction.prototype.encoded=
  609.     function(){return("_sessionid="+this.tid+"&_sessionkey="+this.key);}
  610.  
  611. TaminoTransaction.prototype.update=function(node)
  612. {
  613.     var root=node.getElementsByTagName("ino:response").item(0);
  614.     var tid;
  615.     var key;
  616.     if    (root)
  617.         {
  618.         tid =root.getAttribute("ino:sessionid");
  619.         key = root.getAttribute("ino:sessionkey");
  620.         
  621.         if    (this.tid == tid)
  622.             {
  623.             this.key=key;
  624.             this.errorNo=0;
  625.             this.errorText="";
  626.             return(true); 
  627.             }
  628.         }
  629.     else tid="no root";
  630.     this.errorNo=inoSessionIdErrorNo;
  631.     this.errorText=TaminoClientErrorText(inoSessionIdErrorNo,tid,key);
  632.     return(false);
  633. }
  634.     
  635. TaminoClient.prototype.define=function(node)
  636.     {
  637.     
  638.     var REQ=new ActiveXObject("Microsoft.XMLHTTP");
  639.     this.lastQuery=this.XMLDB;
  640.     REQ.open("POST",this.lastQuery,false,this.user,this.password);
  641.     REQ.setRequestHeader("User-Agent",this.userAgent);
  642.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  643.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  644.     REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  645.     REQ.send("_define="+this.escape(this.xmlHeader+node.xml));
  646.     result=new TaminoResult(this,REQ);
  647.     return(result);
  648. }
  649. TaminoClient.prototype.undefine=function(query)
  650.     {
  651.     var REQ=new ActiveXObject("Microsoft.XMLHTTP");
  652.     this.lastQuery=this.XMLDB;
  653.     REQ.open("POST",this.lastQuery,false,this.user,this.password);
  654.     REQ.setRequestHeader("User-Agent",this.userAgent);
  655.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  656.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  657.     REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  658.     REQ.send("_undefine="+this.escape(query));
  659.     result=new TaminoResult(this,REQ);
  660.     return(result);
  661.     }
  662.         
  663. TaminoClient.prototype.loadChildren=function(node)
  664.     {
  665.     var elements=node.childNodes;
  666.     var length=elements.length;
  667.     var index=0;
  668.     var buffer = "";
  669.     var errorNo=0;
  670.     var maxBunch=this.maxBunch;
  671.     var REQ;
  672.     var result;
  673.     if    (arguments.length > 1) maxBunch=arguments[1];
  674.     if    (!maxBunch) maxBunch=100;
  675.     this.lastQuery=this.XMLDB;
  676.     while (!errorNo && index < length)
  677.         {
  678.         var bunch = 0;
  679.         buffer="";
  680.         while     (!errorNo && bunch<maxBunch && index<length)
  681.             {
  682.             buffer=buffer+elements.item(index).xml;
  683.             bunch++;
  684.             index++;
  685.             }
  686.         if (!errorNo && bunch)
  687.             {
  688.             REQ=new ActiveXObject("Microsoft.XMLHTTP");
  689.             REQ.open("POST",this.lastQuery,false,this.user,this.password);
  690.             var session=this.tEncoded();
  691.             if    (session) session=session+"&";
  692.             REQ.setRequestHeader("User-Agent",this.userAgent);
  693.             REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  694.             REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  695.             REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  696.             REQ.send(session+"_PROCESS="+this.escape(this.xmlHeader+buffer));
  697.             result=new TaminoResult(this,REQ);
  698.             errorNo=result.errorNo;
  699.             }
  700.         }
  701.     if    (!result)
  702.         result=new TaminoResult(this);//should give a zero set
  703.         
  704.     return(result);    
  705.     }
  706. TaminoClient.prototype.remoteUpdate=function(verb,reurl,xPath,node)
  707.     {
  708.     var payload="";
  709.     var nodeType=node.nodeType;
  710.     if    (node && node.nodeType != NODE_ELEMENT)
  711.         {
  712.             var r = new TaminoResult(this,null);
  713.             r.errorNo=inoInvalidNodeTypeNo;
  714.             r.errorText=TaminoClientErrorText(inoInvalidNodeTypeNo,node.nodeType);
  715.             return(r);
  716.         }
  717.     if    (node)
  718.         {
  719.         payload="&_newnode="+this.escape(this.header+node.xml);
  720.         }
  721.     this.lastQuery=this.XMLDB;
  722.     REQ=new ActiveXObject("Microsoft.XMLHTTP");
  723.     REQ.open("POST",this.lastQuery,false,this.user,this.password);
  724.     var session=this.tEncoded();
  725.     if    (session) session=session+"&";
  726.     REQ.setRequestHeader("User-Agent",this.userAgent);
  727.     REQ.setRequestHeader("Accept-Language",this.acceptLanguage);
  728.     REQ.setRequestHeader("Accept-Charset",this.acceptCharset);
  729.     REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset="+this.charset);
  730.     REQ.send(session+verb+"="+reurl+"&_xpath="+this.escape(xPath)+payload);
  731.     var r = new TaminoResult(this,REQ);
  732.     return(r);
  733. }
  734. TaminoClient.prototype.insertBefore=function(reurl,xpath,node)
  735. {return(this.remoteUpdate("_insertBefore",reurl,xpath,node));}
  736. TaminoClient.prototype.appendChild=function(reurl,xpath,node)
  737. {return(this.remoteUpdate("_appendChild",reurl,xpath,node));}
  738. TaminoClient.prototype.replaceNode=function(reurl,xpath,node)
  739. {return(this.remoteUpdate("_replaceNode",reurl,xpath,node));}
  740. TaminoClient.prototype.insertBefore=function(reurl,xpath)
  741. {return(this.remoteUpdate("_removeNode",reurl,xpath));}
  742.  
  743. //For use with ASP replace this line with